package com.sign2024.sign2024project.capitalconstruction.service.impl;

import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.sign2024.sign2024core.entry.capitalconstruction.JjMajorCollect;
import com.sign2024.sign2024core.entry.capitalconstruction.JjProgect;
import com.sign2024.sign2024core.entry.projecttask.ProjectTask;
import com.sign2024.sign2024project.capitalconstruction.mapper.*;
import com.sign2024.sign2024project.capitalconstruction.param.JjParam;
import com.sign2024.sign2024project.capitalconstruction.service.CreateJJProgect;
import com.sign2024.sign2024project.capitalconstruction.vo.JjProgectVo;
import com.sign2024.sign2024project.projecttask.mapper.ProjectTaskMapper;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * @author yujie
 * @data 2024/8/24 13:59
 */
@Service
public class CreateJJProgectImpl implements CreateJJProgect {

    // 计划清单
    @Resource
    private JjPlanInventoryMapper jjPlanInventoryMapper;

    // 专业汇总
    @Resource
    private JjMajorCollectMapper jjMajorCollectMapper;

    // 获取记录
    @Resource
    private JjRecordCollectMapper jjRecordCollectMapper;

    // 任务
    @Resource
    private ProjectTaskMapper projectTaskMapper;

    // 基建抽取方案
    @Resource
    private JjProgectMapper jjProgectMapper;

    @Resource
    private JjHistoryDataMapper jjHistoryDataMapper;


//    @Override
//    public void processingGcDate(Integer taskId) {
//        // 根据 ecp 匹配标段类型 以及 分标名称
//        List<JjProgectVo> jjProgectVos = jjPlanInventoryMapper.selectJjDateById(taskId);
//
//        // 根据 ecp 统计分包数量
//        for (JjProgectVo jj : jjProgectVos) {
//            int kindNameNum = jjPlanInventoryMapper.countKindNameNum(taskId, jj.getEpcTwo());
//            jj.setKindNameNum(kindNameNum);
//
//            List<String> depaList = jjPlanInventoryMapper.selectComDepa(taskId, jj.getEpcTwo());// 处理 部分 合并
//            jj.setComDepa(joinStrings(depaList));
//
//            // 家数（去重） 使用 ecp 去匹配家数
//            int familyNumber = jjRecordCollectMapper.countFamilyNumber(taskId, jj.getEpcTwo());
//            jj.setFamilyNumber(familyNumber);
//
//            int familyNext = jjRecordCollectMapper.countFamilyNext(taskId, jj.getEpcTwo());
//            jj.setFamilyNext(familyNext);
//
//            // 匹配商务专家专业， 以及技术专家专业
////            JjMajorCollect major = jjMajorCollectMapper.selectMajorByIdAndEcp(taskId, jj.getEpcTwo());
//            JjMajorCollect major = jjMajorCollectMapper.selectMajorByIdAndEcp(jj.getEpcTwo());
//            if (major != null) {
//                // 添加商务专家专业 1 - 5
//                // 使用 Optional 来简化四级匹配逻辑
//                Optional<String> bosSignMajor = Stream.of(
//                                major.getBiesMajorOne(),
//                                major.getBiesMajorTwo(),
//                                major.getBiesMajorThree(),
//                                major.getBiesMajorFour(),
//                                major.getBiesMajorFive()
//                        )
//                        .filter(Objects::nonNull)
//                        .findFirst();
//
//                // 如果找到有效的专家专业，就设置到 jj 中
//                bosSignMajor.ifPresent(jj::setBossSignMajor);
//
//                // 匹配技术专家专业 1 - 7
//                Optional<String> signMajor = Stream.of(
//                                major.getSkillMajorOne(),
//                                major.getSkillMajorTwo(),
//                                major.getSkillMajorThree(),
//                                major.getSkillMajorFour(),
//                                major.getSkillMajorFive(),
//                                major.getSkillMajorSix(),
//                                major.getSkillMajorEight()
//                        )
//                        .filter(Objects::nonNull)
//                        .findFirst();
//                signMajor.ifPresent(jj::setSignMajor);
//            }
//        }
//
//        // 按照标段类型 将其 进行数据提取出来
//        // 将根据 signType 字段分组
//        Map<String, List<JjProgectVo>> groupedBySignType = jjProgectVos.stream()
//                .collect(Collectors.groupingBy(JjProgectVo::getSignType));
//        // 将分组结果转换为 List<List<JjProgectVo>>
//        List<List<JjProgectVo>> result = new ArrayList<>(groupedBySignType.values());
//
//        // TODO 排序部分暂时未写
//        // 对其进行排序， 如果是施工类 就按照先 变电 再 土建 以及其他
//        // 如果是 服务 类 先 设计 再 监理
//        // 进行商务分组
//        // 先排序
//
//        // 获取 任务公式 信息
//        ProjectTask projectTask = projectTaskMapper.selectById(taskId);
//        // 技术评标量(家数/家次)
//        String skillFamily = projectTask.getSkillFamily();
//        // 商务专家专业
//        String businessFamily = projectTask.getBusinessFamily();
//
//        // 商务分组  计算出商务每个类总人数
//        Map<String, Integer> typeMap = new HashMap<>();
//        if (StringUtils.isNotEmpty(result)) {
//            for (List<JjProgectVo> list : result) {
//                int bossTotalPerson = 0;
//                // 判断是家数还是家次
//                if (businessFamily.equals("家数")) {
//                    int totalFamilyNumber = list.stream()
//                            .mapToInt(JjProgectVo::getFamilyNumber)
//                            .sum();
//                    // 向上取整 Math.ceil()  商务
//                    double v = Double.valueOf(totalFamilyNumber) / projectTask.getBusinessSignNum();
//                    bossTotalPerson = (int) Math.ceil(v);
//                } else {
//                    // 计算 familyNext 的总和
//                    int totalFamilyNext = list.stream()
//                            .mapToInt(JjProgectVo::getFamilyNext)
//                            .sum();
//                    // 商务
//                    double v = Double.valueOf(totalFamilyNext) / projectTask.getBusinessSignNum();
//                    bossTotalPerson = (int) Math.ceil(v);
//                }
//                typeMap.put(list.get(0).getSignType(), bossTotalPerson);
//            }
//        }
//
//        // 将 商务分组数据 存储到 map 中
//        Map<String, List<JjProgectVo>> tempMap = new HashMap<>();
//
//        for (int i = 0; i < result.size(); i++) {
//            // 获取 该 list 中的 标段类型
//            String signType = result.get(i).get(0).getSignType();
//            // 根据类型 获取 该类型所需总人数
//            Integer integer = typeMap.get(signType);
//
//            // 对 result.get(i) 进行排序， 排列顺序是 如果其 epcTwo 包含
//            // 排序 暂时先不写
//            // 对 result.get(i) 数据进行排序
//            Collections.sort(result.get(i), new Comparator<JjProgectVo>() {
//                @Override
//                public int compare(JjProgectVo o1, JjProgectVo o2) {
//                    String epcTwo1 = o1.getEpcTwo();
//                    String epcTwo2 = o2.getEpcTwo();
//
//                    // 如果 signType 包含 "施工"
//                    if (signType.contains("施工")) {
//                        // 排序规则是，epcTwo 字段中包含 "变电" 的排在最前面，其次是 "土建"，其他的排在后面
//                        if (epcTwo1.contains("变电") && !epcTwo2.contains("变电")) {
//                            return -1;
//                        } else if (!epcTwo1.contains("变电") && epcTwo2.contains("变电")) {
//                            return 1;
//                        } else if (epcTwo1.contains("土建") && !epcTwo2.contains("土建")) {
//                            return -1;
//                        } else if (!epcTwo1.contains("土建") && epcTwo2.contains("土建")) {
//                            return 1;
//                        }
//                    }
//
//                    // 如果 signType 包含 "服务"
//                    if (signType.contains("服务")) {
//                        // 排序规则是，epcTwo 字段中包含 "设计" 的排在最前面，其次是 "监理"，其他的排在后面
//                        if (epcTwo1.contains("设计") && !epcTwo2.contains("设计")) {
//                            return -1;
//                        } else if (!epcTwo1.contains("设计") && epcTwo2.contains("设计")) {
//                            return 1;
//                        } else if (epcTwo1.contains("监理") && !epcTwo2.contains("监理")) {
//                            return -1;
//                        } else if (!epcTwo1.contains("监理") && epcTwo2.contains("监理")) {
//                            return 1;
//                        }
//                    }
//
//                    // 如果没有匹配的规则，按默认顺序返回 0
//                    return 0;
//                }
//            });
//
//            // 获取 该类型 下小组数 以及人员数
//            List<Integer> bossClassNumList =
//                    DealClassUtils.dealGcClassNum(integer, projectTask.getBusinessStart(), projectTask.getBusinessEnd());
//
//
//            // 判断 有几个小组
//            if (bossClassNumList.size() == 1) {
//                // 小组人数为 1 直接赋值
//                // 存储数据
//                List<JjProgectVo> oneList = new ArrayList<>();
//                for (int j = 0; j < result.get(i).size(); j++) {
//                    result.get(i).get(j).setBossTotalNum(bossClassNumList.get(0));
//                    oneList.add(result.get(i).get(j));
//                }
//                String className = "商务" + convertToChinese(tempMap.size() + 1) + "组";
//                tempMap.put(className, oneList);
//            } else if (bossClassNumList.size() == 2) {
//                // 为两组 分出一组 即可， 剩下即为一组
//                List<JjProgectVo> oneList = new ArrayList<>();
//                List<JjProgectVo> twoList = new ArrayList<>();
//
//                // 该小组 预计总评标量
//                Integer skillSignNum = projectTask.getBusinessSignNum() * bossClassNumList.get(0);
//                // 当前次 的总和
//                int total = 0;
//                // 下一次数据总和
//                int nextValue = 0;
//                //  遍历 集合计算 列表中的评标量
//                for (int j = 0; j < result.get(i).size(); ) {
//                    // 判断是家数还是家次
//                    if (businessFamily.equals("家数")) {
//                        total += result.get(i).get(j).getFamilyNumber();
//                    } else {
//                        total += result.get(i).get(j).getFamilyNext();
//                    }
//
//                    if (total <= skillSignNum) {
//                        // 向map中添加数据值
//                        result.get(i).get(j).setBossTotalNum(bossClassNumList.get(0));
//                        oneList.add(result.get(i).get(j));
//                        result.get(i).remove(j);
//                    } else {
//                        // 不满足 结束循环，避免其 无限循环
//                        break;
//                    }
//                    nextValue += 1;
//                    if (nextValue > result.get(i).size()) {
//                        // 数据标记，避免无限循环
//                        break;
//                    }
//                }
//
//                String className = "商务" + convertToChinese(tempMap.size() + 1) + "组";
//                tempMap.put(className, oneList);
//
//                for (int j = 0; j < result.get(i).size(); j++) {
//                    result.get(i).get(j).setBossTotalNum(bossClassNumList.get(1));
//                    twoList.add(result.get(i).get(j));
//                }
//                String className2 = "商务" + convertToChinese(tempMap.size() + 1) + "组";
//                tempMap.put(className2, twoList);
//            } else if (bossClassNumList.size() > 2) {
//                // 这里 是3组 及以上
//                // 循环小组
//                for (int j = 0; j < bossClassNumList.size(); j++) {
//                    if (j == bossClassNumList.size() - 1) {
//                        // 最后一次循环直接处理数据
//                        List<JjProgectVo> oneList = new ArrayList<>();
//                        if (!result.get(i).isEmpty()) {
//                            for (int k = 0; k < result.get(i).size(); k++) {
//                                result.get(i).get(k).setBossTotalNum(bossClassNumList.get(j));
//                                oneList.add(result.get(i).get(k));
//                            }
//                            String className = "商务" + convertToChinese(tempMap.size() + 1) + "组";
//                            tempMap.put(className, oneList);
//                        }
//                    } else {
//                        List<JjProgectVo> oneList = new ArrayList<>();
//                        // 该小组 预计总评标量
//                        Integer skillSignNum = projectTask.getBusinessSignNum() * bossClassNumList.get(j);
//                        int total = 0;
//                        // 下一次数据总和
//                        int nextValue = 0;
//                        //  遍历 集合计算 列表中的评标量
//                        for (int k = 0; k < result.get(i).size(); ) {
//                            // 判断是家数还是家次
//                            if (businessFamily.equals("家数")) {
//                                total += result.get(i).get(k).getFamilyNumber();
//                            } else {
//                                total += result.get(i).get(k).getFamilyNext();
//                            }
//
//                            if (total <= skillSignNum) {
//                                // 向map中添加数据值
//                                result.get(i).get(k).setBossTotalNum(bossClassNumList.get(j));
//                                oneList.add(result.get(i).get(k));
//                                result.get(i).remove(k);
//                            } else {
//                                // 不满足 重新记录数据
//                                break;
//                            }
//
//                            nextValue += 1;
//                            if (nextValue > result.get(i).size()) {
//                                // 数据标记，避免无限循环
//                                break;
//                            }
//                        }
//                        // 获取组名
//                        String className = "商务" + convertToChinese(tempMap.size() + 1) + "组";
//                        tempMap.put(className, oneList);
//                    }
//                }
//            }
//        }
//
//        // 商务组 人数 细分
//        List<JjProgectVo> bossList = new ArrayList<>();
//
//        for (int i = 0; i < tempMap.size(); i++) {
//            String keyName = "商务" + convertToChinese(i + 1) + "组";
//            List<JjProgectVo> voList = tempMap.get(keyName);
//            // 获取该小组 总人数
//            Integer bossTotalNum = voList.get(0).getBossTotalNum();
//            // 分配异地人数
//            //  （专家总人数+1）÷3（向上取整）
//            double v = Double.valueOf((bossTotalNum + 1)) / projectTask.getOtherSkill();
//            int bossOtherNum = (int) Math.ceil(v);
//            // 最后必须确保 本地 人数 大于 projectTask.getOtherLocal() (本地保留人数)
//
//            // 本地
//            int localNum = bossTotalNum - bossOtherNum;
//            if (localNum < projectTask.getOtherLocal()) {
//                // 如果不满足 任务 设定，倒退异地
//                localNum = projectTask.getOtherLocal();
//                bossOtherNum = bossTotalNum - localNum;
//            }
//
//            // 7（4个安徽专家）   7（4个异地）
//            String personStr = bossTotalNum + "（" + bossOtherNum + "个异地）";
//
//            // 求 集合总数
//            int totalFamily = 0;
//            if (businessFamily.equals("家数")) {
//                totalFamily = voList.stream()
//                        .mapToInt(JjProgectVo::getFamilyNumber)
//                        .sum();
//            } else {
//                // 计算 familyNext 的总和
//                totalFamily = voList.stream()
//                        .mapToInt(JjProgectVo::getFamilyNext)
//                        .sum();
//            }
//
//            int count = bossTotalNum;
//            for (JjProgectVo gc : voList) {
//                // 遍历集合 求占比
//                int temp = 0;
//                if (businessFamily.equals("家数")) {
//                    temp = gc.getFamilyNumber();
//                } else {
//                    // 计算 familyNext 的总和
//                    temp = gc.getFamilyNext();
//                }
//
//                // 计算占比
//                double proportion = (double) temp / totalFamily;
//                // 向上取整 Math.ceil()
//                int personNum = (int) Math.ceil(proportion * bossTotalNum);
//
//                if (count - personNum < 0) {
//                    personNum = count;
//                }
//
//                // 更新count值
//                count -= personNum;
//
//                // 只在count大于0时进行赋值操作
//                if (count >= 0) {
//                    if (personNum > 0) {
//                        gc.setBossMajorNum(personNum);
//                    }
//                }
//                // bossTotalStr  商务组专家人数(拼接字符串)
//                gc.setBossTotalStr(personStr);
////                // 分组  变电土建商务组7人
//                String bossClassName = keyName + bossTotalNum + "人";
//                gc.setBossClassStr(bossClassName);
//                gc.setBossClass(keyName);
//                bossList.add(gc);
//            }
//        }
//
//        // 技术 分组
//        // 将根据 signType 字段分组
//        Map<String, List<JjProgectVo>> skillBySignType = bossList.stream()
//                .collect(Collectors.groupingBy(JjProgectVo::getSignType));
//        // 将分组结果转换为
//        List<List<JjProgectVo>> skillResult = new ArrayList<>(skillBySignType.values());
//
//        // 技术 每个类型分为多少人
//        Map<String, Integer> skillTypeMap = new HashMap<>();
//        // 计算出 每个类型所需 总人数
//        if (StringUtils.isNotEmpty(skillResult)) {
//            for (List<JjProgectVo> list : skillResult) {
//                int skillTotalPerson = 0;
//                // 判断是家数还是家次
//                if (skillFamily.equals("家数")) {
//                    int totalFamilyNumber = list.stream()
//                            .mapToInt(JjProgectVo::getFamilyNumber)
//                            .sum();
//                    // 向上取整 Math.ceil()
//                    double v = Double.valueOf(totalFamilyNumber) / projectTask.getSkillSignNum();
//                    skillTotalPerson = (int) Math.ceil(v);
//                } else {
//                    // 计算 familyNext 的总和
//                    int totalFamilyNext = list.stream()
//                            .mapToInt(JjProgectVo::getFamilyNext)
//                            .sum();
//                    double v = Double.valueOf(totalFamilyNext) / projectTask.getSkillSignNum();
//                    skillTotalPerson = (int) Math.ceil(v);
//                }
//                skillTypeMap.put(list.get(0).getSignType(), skillTotalPerson);
//            }
//        }
//
//        // 直接去存储数据
//        Map<String, List<JjProgectVo>> skillMap = new HashMap<>();
//        for (int i = 0; i < skillResult.size(); i++) {
//            // 获取 该 list 中的 标段类型
//            String signType = skillResult.get(i).get(0).getSignType();
//            // 根据类型 获取 该类型所需总人数
//            Integer integer = skillTypeMap.get(signType);
//
//            // 获取 该类型 下小组数 以及人员数
//            List<Integer> skillClassNumList =
//                    DealClassUtils.dealGcClassNum(integer, projectTask.getSkillStart(), projectTask.getSkillEnd());
//
//            // 判断 有几个小组
//            if (skillClassNumList.size() == 1) {
//                // 小组人数为 1 直接赋值
//                // 存储数据
//                List<JjProgectVo> oneList = new ArrayList<>();
//                for (int j = 0; j < skillResult.get(i).size(); j++) {
//                    skillResult.get(i).get(j).setSkillTotalNum(skillClassNumList.get(0));
//                    oneList.add(skillResult.get(i).get(j));
//                }
//
//                String className = "技术" + convertToChinese(skillMap.size() + 1) + "组";
//                skillMap.put(className, oneList);
//            } else if (skillClassNumList.size() == 2) {
//                // 为两组 分出一组 即可， 剩下即为一组
//                List<JjProgectVo> oneList = new ArrayList<>();
//                List<JjProgectVo> twoList = new ArrayList<>();
//
//                // 该小组 预计总评标量
//                Integer skillSignNum = projectTask.getSkillSignNum() * skillClassNumList.get(0);
//                // 当前次 的总和
//                int total = 0;
//                // 下一次数据总和
//                int nextValue = 0;
//                //  遍历 集合计算 列表中的评标量
//                for (int j = 0; j < skillResult.get(i).size(); ) {
//                    // 判断是家数还是家次
//                    if (skillFamily.equals("家数")) {
//                        total += skillResult.get(i).get(j).getFamilyNumber();
//                    } else {
//                        total += skillResult.get(i).get(j).getFamilyNext();
//                    }
//
//                    if (total <= skillSignNum) {
//                        // 向map中添加数据值
//                        skillResult.get(i).get(j).setSkillTotalNum(skillClassNumList.get(0));
//                        oneList.add(skillResult.get(i).get(j));
//                        skillResult.get(i).remove(j);
//                    } else {
//                        // 不满足 结束循环，避免其 无限循环
//                        break;
//                    }
//                    nextValue += 1;
//                    if (nextValue > skillResult.get(i).size()) {
//                        // 数据标记，避免无限循环
//                        break;
//                    }
//                }
//
//                String className = "技术" + convertToChinese(skillMap.size() + 1) + "组";
//                skillMap.put(className, oneList);
//
//                for (int j = 0; j < skillResult.get(i).size(); j++) {
//                    skillResult.get(i).get(j).setSkillTotalNum(skillClassNumList.get(1));
//                    twoList.add(skillResult.get(i).get(j));
//                }
//                String className2 = "技术" + convertToChinese(skillMap.size() + 1) + "组";
//                skillMap.put(className2, twoList);
//            } else if (skillClassNumList.size() > 2) {
//                // 这里 是3组 及以上
//                // 循环小组
//                for (int j = 0; j < skillClassNumList.size(); j++) {
//                    if (j == skillClassNumList.size() - 1) {
//                        // 最后一次循环直接处理数据
//                        List<JjProgectVo> oneList = new ArrayList<>();
//                        if (!skillResult.get(i).isEmpty()) {
//                            for (int k = 0; k < skillResult.get(i).size(); k++) {
//                                skillResult.get(i).get(k).setSkillTotalNum(skillClassNumList.get(j));
//                                oneList.add(skillResult.get(i).get(k));
//                            }
//                            String className = "技术" + convertToChinese(skillMap.size() + 1) + "组";
//                            skillMap.put(className, oneList);
//                        }
//                    } else {
//                        List<JjProgectVo> oneList = new ArrayList<>();
//                        // 该小组 预计总评标量
//                        Integer skillSignNum = projectTask.getSkillSignNum() * skillClassNumList.get(j);
//                        int total = 0;
//                        // 下一次数据总和
//                        int nextValue = 0;
//                        //  遍历 集合计算 列表中的评标量
//                        for (int k = 0; k < skillResult.get(i).size(); ) {
//                            // 判断是家数还是家次
//                            if (skillFamily.equals("家数")) {
//                                total += skillResult.get(i).get(k).getFamilyNumber();
//                            } else {
//                                total += skillResult.get(i).get(k).getFamilyNext();
//                            }
//
//                            if (total <= skillSignNum) {
//                                // 向map中添加数据值
//                                skillResult.get(i).get(k).setSkillTotalNum(skillClassNumList.get(j));
//                                oneList.add(skillResult.get(i).get(k));
//                                skillResult.get(i).remove(k);
//                            } else {
//                                // 不满足 重新记录数据
//                                break;
//                            }
//
//                            nextValue += 1;
//                            if (nextValue > skillResult.get(i).size()) {
//                                // 数据标记，避免无限循环
//                                break;
//                            }
//                        }
//                        // 获取组名
//                        String className = "技术" + convertToChinese(skillMap.size() + 1) + "组";
//                        skillMap.put(className, oneList);
//                    }
//                }
//            }
//        }
//
//        List<JjProgectVo> skillVoList = new ArrayList<>();
//        for (int i = 0; i < skillMap.size(); i++) {
//            String keyName = "技术" + convertToChinese(i + 1) + "组";
//            List<JjProgectVo> voList = skillMap.get(keyName);
//            // 获取该小组 总人数
//            Integer skillTotalNum = voList.get(0).getSkillTotalNum();
//            // 分配异地人数
//            //  （技术专家总人数+1）÷3（向上取整）
//            double v = Double.valueOf((skillTotalNum + 1)) / projectTask.getOtherSkill();
//            int skillOtherNum = (int) Math.ceil(v);
//            // 最后必须确保 本地 人数 大于 projectTask.getOtherLocal() (本地保留人数)
//            // 求 集合总数
//            int totalFamily = 0;
//            if (skillFamily.equals("家数")) {
//                totalFamily = voList.stream()
//                        .mapToInt(JjProgectVo::getFamilyNumber)
//                        .sum();
//            } else {
//                // 计算 familyNext 的总和
//                totalFamily = voList.stream()
//                        .mapToInt(JjProgectVo::getFamilyNext)
//                        .sum();
//            }
//
//            int count = skillTotalNum;
//            for (JjProgectVo gc : voList) {
//                // 遍历集合 求占比
//                int temp = 0;
//                if (skillFamily.equals("家数")) {
//                    temp = gc.getFamilyNumber();
//                } else {
//                    // 计算 familyNext 的总和
//                    temp = gc.getFamilyNext();
//                }
//
//                // 计算占比
//                double proportion = (double) temp / totalFamily;
//                // 向上取整 Math.ceil()
//                int personNum = (int) Math.ceil(proportion * skillTotalNum);
//
//                if (count - personNum < 0) {
//                    personNum = count;  // 分配剩余的全部
//                }
//
//                // 更新count值
//                count -= personNum;
//
//                // 只在count大于0时进行赋值操作
//                if (count >= 0) {
//                    if (personNum > 0) {
//                        gc.setSkillMajorNum(personNum);
//                    }
//                }
//                // 分组
//                String skillClassName = keyName + skillTotalNum + "人";
//                gc.setSkillClassStr(skillClassName);
//                gc.setSkillClass(keyName);
//                skillVoList.add(gc);
//            }
//        }
//
//
//        jjProgectMapper.insertBatchJj(skillVoList, taskId);
////        return skillVoList;
//    }

    @Override
    public void processingGcDate(Integer taskId) {
        // 根据 ecp 匹配标段类型 以及 分标名称
        List<JjProgectVo> jjProgectVos = jjPlanInventoryMapper.selectJjDateById(taskId);

        // 根据 ecp 统计分包数量
        int serialNumber = 1;
        for (JjProgectVo jj : jjProgectVos) {
            // 对 数值 顺序标记
            jj.setSerialNumber(serialNumber);
            serialNumber += 1;

            int kindNameNum = jjPlanInventoryMapper.countKindNameNum(taskId, jj.getEpcTwo());
            jj.setKindNameNum(kindNameNum);

            // 处理 部分 合并
            List<String> depaList = jjPlanInventoryMapper.selectComDepa(taskId, jj.getEpcTwo());
            jj.setComDepa(joinStrings(depaList));

            // 家数（去重） 使用 ecp 去匹配家数
            int familyNumber = jjRecordCollectMapper.countFamilyNumber(taskId, jj.getEpcTwo());
            jj.setFamilyNumber(familyNumber);
            int familyNext = jjRecordCollectMapper.countFamilyNext(taskId, jj.getEpcTwo());
            jj.setFamilyNext(familyNext);


            JjMajorCollect major = jjMajorCollectMapper.selectMajorByIdAndEcp(jj.getEpcTwo());
            if (major != null) {
                // 添加商务专家专业 1 - 5
                // 使用 Optional 来简化四级匹配逻辑
                Optional<String> bosSignMajor = Stream.of(
                                major.getBiesMajorOne(),
                                major.getBiesMajorTwo(),
                                major.getBiesMajorThree(),
                                major.getBiesMajorFour(),
                                major.getBiesMajorFive()
                        )
                        .filter(Objects::nonNull)
                        .findFirst();

                // 如果找到有效的专家专业，就设置到 jj 中
                bosSignMajor.ifPresent(jj::setBossSignMajor);

                // 匹配技术专家专业 1 - 7
                Optional<String> signMajor = Stream.of(
                                major.getSkillMajorOne(),
                                major.getSkillMajorTwo(),
                                major.getSkillMajorThree(),
                                major.getSkillMajorFour(),
                                major.getSkillMajorFive(),
                                major.getSkillMajorSix(),
                                major.getSkillMajorEight()
                        )
                        .filter(Objects::nonNull)
                        .findFirst();
                signMajor.ifPresent(jj::setSignMajor);
            }
        }

        // 按照标段类型 将其 进行数据提取出来
        // 将根据 signType 字段分组
        Map<String, List<JjProgectVo>> groupedBySignType = jjProgectVos.stream()
                .collect(Collectors.groupingBy(JjProgectVo::getSignType));

        // 获取去重后的比标段类型列表，保持原始顺序
        List<String> signTypes = jjProgectVos.stream()
                .map(JjProgectVo::getSignType)
                .collect(Collectors.toCollection(LinkedHashSet::new))
                .stream()
                .collect(Collectors.toList());

        // 将分组结果转换为 List<List<JjProgectVo>>
//        List<List<JjProgectVo>> skillResult = new ArrayList<>(groupedBySignType.values());
        List<List<JjProgectVo>> skillResult = new ArrayList<>();
        for (String type : signTypes) {
            List<JjProgectVo> vos = groupedBySignType.get(type);
            skillResult.add(vos);
        }


        // 获取 任务公式 信息
        ProjectTask projectTask = projectTaskMapper.selectById(taskId);
        // 技术评标量(家数/家次)
        String skillFamily = projectTask.getSkillFamily();

        // 不同 分标 下 进行 分组
        Map<String, List<JjProgectVo>> skillTypeMap = new HashMap<>();
        for (List<JjProgectVo> list : skillResult) {
            List<JjProgectVo> vos = new ArrayList<>();
            // 存储 查询不到的数据
            List<JjProgectVo> tempVos = new ArrayList<>();
            // 先对 wzVos 列表中的每个对象进行处理
//            for (JjProgectVo w : list) {
//                // 频次
//                Integer frequency = projectTask.getFrequency();
//                if (frequency == null) {
//                    frequency = 1;
//                }
//                // 查询其历史数据  以及 频次
//                List<String> historyList = jjHistoryDataMapper.selectJjHistoryName(w.getSignName(), frequency);
//                if (historyList.isEmpty()) {
//                    tempVos.add(w);
//                } else {
//                    List<JjProgectVo> wz = new ArrayList<>();
//                    for (String historyName : historyList) {
//                        boolean existsInWzVos = list.stream()
//                                .anyMatch(vo -> vo.getSignName().equals(historyName));
//                        if (existsInWzVos) {
//                            boolean existsInWzProgectVos = vos.stream()
//                                    .anyMatch(vo -> vo.getSignName().equals(historyName));
//                            if (!existsInWzProgectVos) {
//                                JjProgectVo voToAdd = list.stream()
//                                        .filter(vo -> vo.getSignName().equals(historyName))
//                                        .findFirst()
//                                        .orElse(null);
//                                if (voToAdd != null) {
//                                    vos.add(voToAdd);
//                                    wz.add(voToAdd);
//                                }
//                            }
//                        }
//                    }
//                    String className = "技术" + convertToChinese(skillTypeMap.size() + 1) + "组";
//                    if (!wz.isEmpty()) {
//                        skillTypeMap.put(className, wz);
//                    }
//                }
//            }


            for (JjProgectVo w : list) {
                // 在 循环 之前， 先判断 是否以使用过
                boolean booleanVos = vos.stream()
                        .anyMatch(vo -> vo.getSignName().equals(w.getSignName()));
                if (!booleanVos) {
                    // 未 被 使用 对数据进行处理
                    // 频次
                    Integer frequency = projectTask.getFrequency();
                    if (frequency == null) {
                        frequency = 1;
                    }
                    // 查询其历史数据  以及 频次
                    List<String> historyList = jjHistoryDataMapper.selectJjHistoryName(w.getSignName(), frequency);
                    if (historyList.isEmpty()) {
                        tempVos.add(w);
                        vos.add(w);
                    } else {
                        List<JjProgectVo> wz = new ArrayList<>();
                        // 修改 一下， 通过 哪一个 查询 出来的，就先 匹配哪一个
                        // 先判断 已使用 的数据 是否 存在
                        boolean existsInWzProgectVos = vos.stream()
                                .anyMatch(vo -> vo.getSignName().equals(w.getSignName()));
                        if (!existsInWzProgectVos) {
                            // 未 被使用过， 与 历史频次数据 进行对比
                            boolean existsInWzVos = list.stream()
                                    .anyMatch(vo -> vo.getSignName().equals(w.getSignName()));
                            if (existsInWzVos) {
                                // 如果历史 中 存在
                                // 判断是否 在 整体 集合中
                                JjProgectVo voToAdd = list.stream()
                                        .filter(vo -> vo.getSignName().equals(w.getSignName()))
                                        .findFirst()
                                        .orElse(null);
                                if (voToAdd != null) {
                                    vos.add(voToAdd);
                                    wz.add(voToAdd);
                                }
                            }
                        }

                        for (String historyName : historyList) {
                            boolean existsInWzProgectVos2 = vos.stream()
                                    .anyMatch(vo -> vo.getSignName().equals(historyName));
                            if (!existsInWzProgectVos2) {
                                boolean existsInWzVos = list.stream()
                                        .anyMatch(vo -> vo.getSignName().equals(historyName));
                                if (existsInWzVos) {
                                    JjProgectVo voToAdd = list.stream()
                                            .filter(vo -> vo.getSignName().equals(historyName))
                                            .findFirst()
                                            .orElse(null);
                                    if (voToAdd != null) {
                                        vos.add(voToAdd);
                                        wz.add(voToAdd);
                                    }
                                }
                            }
                        }

                        String className = "技术" + convertToChinese(skillTypeMap.size() + 1) + "组";
                        if (!wz.isEmpty()) {
                            skillTypeMap.put(className, wz);
                        }
                    }
                }
            }

            // 补充 历史中 查询不到的数据
            if (!tempVos.isEmpty()) {
                Collections.sort(tempVos,
                        Comparator.comparing(JjProgectVo::getSerialNumber));
                String className = "技术" + convertToChinese(skillTypeMap.size() + 1) + "组";
                skillTypeMap.put(className, tempVos);
            }
        }

        // 计算 技术 小组总人数
        // 技术 组 最小人数
        Integer skillStart = projectTask.getSkillStart();
        List<JjProgectVo> skillVoList = new ArrayList<>();
        for (int i = 0; i < skillTypeMap.size(); i++) {
            String keyName = "技术" + convertToChinese(i + 1) + "组";
            List<JjProgectVo> voList = skillTypeMap.get(keyName);
            if (voList.isEmpty()) {
                continue;
            }
            // 计算 商务 组 总人数
            int skillTotalPerson = 0;
            // 判断是家数还是家次
            if (skillFamily.equals("家数")) {
                int totalFamilyNumber = voList.stream()
                        .mapToInt(JjProgectVo::getFamilyNumber)
                        .sum();
                // 向上取整 Math.ceil() 商务人数
                double v = Double.valueOf(totalFamilyNumber) / projectTask.getSkillSignNum();
                // 四舍五入
                skillTotalPerson = (int) Math.ceil(v);
            } else {
                // 计算 familyNext 的总和
                int totalFamilyNext = voList.stream()
                        .mapToInt(JjProgectVo::getFamilyNext)
                        .sum();
                double v = Double.valueOf(totalFamilyNext) / projectTask.getSkillSignNum();
                skillTotalPerson = (int) Math.ceil(v);
            }
//            if (skillTotalPerson <= 0) {
//                skillTotalPerson = 1;
//            }
            if (skillTotalPerson < 0) {
                skillTotalPerson = 0;
            }
            for (JjProgectVo vo : voList) {
                vo.setSkillTotalNum(skillTotalPerson);
            }

            // 求 集合总数
            int totalFamily = 0;
            if (skillFamily.equals("家数")) {
                totalFamily = voList.stream()
                        .mapToInt(JjProgectVo::getFamilyNumber)
                        .sum();
            } else {
                // 计算 familyNext 的总和
                totalFamily = voList.stream()
                        .mapToInt(JjProgectVo::getFamilyNext)
                        .sum();
            }

            // 计算 异地 增加判断 条件 如果 总数 小于 最小值
            Integer skillOtherNum = null;
            Integer skillLocalNum = null;
            if (skillTotalPerson < skillStart) {
                // 不计算异地 所有数据都是本地
                skillLocalNum = skillTotalPerson;
            } else {
                // 计算 异地
                double v = Double.valueOf((skillTotalPerson + 1)) / projectTask.getOtherSkill();
                skillOtherNum = (int) Math.ceil(v);
                skillLocalNum = skillTotalPerson - skillOtherNum;
                if (skillLocalNum < projectTask.getOtherLocal()) {
                    // 如果不满足 任务 设定，倒退异地
                    skillLocalNum = projectTask.getOtherLocal();
                    skillOtherNum = skillTotalPerson - skillLocalNum;
                }
            }

            // 7（4个安徽专家）   7（4个异地）
            String personStr = skillTotalPerson + "（" + skillOtherNum + "个异地）";
            if (skillOtherNum == null) {
                personStr = skillTotalPerson + "";
            }

            // 按照 顺序标记 进行排序
//            Collections.sort(voList,
//                    Comparator.comparing(JjProgectVo::getSerialNumber));

            // 对 小组 人员 进行 分配 ， 专业 进行合并
            // 根据 gc.getSignMajor() 排序，处理 null 值
//            Collections.sort(voList,
//                    Comparator.comparing(JjProgectVo::getSignMajor, Comparator.nullsFirst(Comparator.naturalOrder())));
            // 使用 Map 存储每个 技术专家专业 对应的 FamilyNumber 总和
            Map<String, Integer> sumMap = new HashMap<>();
            for (JjProgectVo gc : voList) {
                // 技术 人数 拼接
                gc.setSkillTotalStr(personStr);
                // 获取 该 组 专业
                String signMajor = gc.getSignMajor();
                int temp = 0;
                if (skillFamily.equals("家数")) {
                    temp = gc.getFamilyNumber();
                } else {
                    temp = gc.getFamilyNext();
                }
                // 如果 SignMajor 已经在 Map 中，则累加 家数/家次
                if (signMajor != null) {
                    if (sumMap.containsKey(signMajor)) {
                        sumMap.put(signMajor, sumMap.get(signMajor) + temp);
                        // 相同专业 只 保留一个
//                        gc.setSignMajor(null);
                    } else {
                        // 否则，将 SignMajor 和 FamilyNumber 放入 Map
                        sumMap.put(signMajor, temp);
                    }
                }
            }


            int count = skillTotalPerson;
            // 将 Map 转换为 List，并根据 Integer 值进行排序
            List<Map.Entry<String, Integer>> sortedList = new ArrayList<>(sumMap.entrySet());
            sortedList.sort((entry1, entry2) -> entry2.getValue().compareTo(entry1.getValue()));

            Map<String, Integer> personMap = new HashMap<>();
            for (Map.Entry<String, Integer> entry : sortedList) {
                int personNum = 0;
                if (entry.getValue() != 0) {
                    // 计算占比
                    double proportion = (double) entry.getValue() / totalFamily;
                    // 向上取整 Math.ceil()
                    personNum = (int) Math.ceil(proportion * skillTotalPerson);
                }
                if (count - personNum < 0) {
                    // 分配剩余的全部
                    personNum = count;
                }
                count -= personNum;
                if (count >= 0) {
                    if (personNum > 0) {
                        personMap.put(entry.getKey(), personNum);
                    }
                }
            }

            Set<String> assignedMajors = new HashSet<>();
            for (Map.Entry<String, Integer> entry : personMap.entrySet()) {
                // 进行专业 对比
                for (JjProgectVo gc : voList) {
                    if (gc.getSignMajor() == null) {
                        continue;
                    }

                    // 这里 设置 一个字符串集合 将 已经赋值过了 专业 放到该 集合之中， 对数据进行赋值时 进行下专业 的对比， 不存在 进行下一步
                    // 如果该专业的技能编号已经赋值过，则跳过
                    if (assignedMajors.contains(gc.getSignMajor())) {
                        continue;
                    }

                    if (gc.getSignMajor().equals(entry.getKey())) {
                        gc.setSkillMajorNum(entry.getValue());
                        // 将该专业加入已赋值集合
                        assignedMajors.add(gc.getSignMajor());
                    }
                }
            }

            for (JjProgectVo gc : voList) {
                // 分组
                String skillClassName = keyName + skillTotalPerson + "人";
                gc.setSkillClassStr(skillClassName);
                gc.setSkillClass(keyName);
                skillVoList.add(gc);
            }
        }

        // 进行 商务 分组
        // 将根据 signType 字段分组
        Map<String, List<JjProgectVo>> groupedBySignType2 = skillVoList.stream()
                .collect(Collectors.groupingBy(JjProgectVo::getSignType));
//        // 获取去重后的比标段类型列表，保持原始顺序
//        List<String> signTypes2 = skillVoList.stream()
//                .map(JjProgectVo::getSignType)
//                .collect(Collectors.toCollection(LinkedHashSet::new))
//                .stream()
//                .collect(Collectors.toList());

        // 将分组结果转换为 List<List<JjProgectVo>>
        List<List<JjProgectVo>> busResult = new ArrayList<>();
        for (String type : signTypes) {
            List<JjProgectVo> vos = groupedBySignType2.get(type);
            busResult.add(vos);
        }

        // 将分组结果转换为
//        List<List<JjProgectVo>> busResult = new ArrayList<>(groupedBySignType2.values());
        // 商务专家专业
        String businessFamily = projectTask.getBusinessFamily();
        // 按照 标段 技术分组 将数据进行封装
        Map<String, Map<String, List<JjProgectVo>>> skillMap = new LinkedHashMap<>();
        for (List<JjProgectVo> list : busResult) {
            // 获取 标段 类型
            String signType = list.get(0).getSignType();
            Map<String, List<JjProgectVo>> gropupBySkill = list.stream()
                    .collect(Collectors.groupingBy(JjProgectVo::getSkillClass));
            skillMap.put(signType, gropupBySkill);
        }
        Integer start = projectTask.getBusinessStart();
        Integer end = projectTask.getBusinessEnd();
        List<List<Integer>> intList = new ArrayList<>();
        int indexFlag = 1;
        for (Map.Entry<String, Map<String, List<JjProgectVo>>> entry : skillMap.entrySet()) {
            List<Integer> list = new ArrayList<>();
            Map<String, List<JjProgectVo>> map = entry.getValue();
            for (int i = 0; i < map.size(); i++) {
                String keyName = "技术" + convertToChinese(indexFlag) + "组";
                indexFlag += 1;
                List<JjProgectVo> voList = skillTypeMap.get(keyName);
                if (voList.isEmpty()) {
                    continue;
                }
                // 计算 商务 组 总人数
                int busTotalPerson = 0;
                // 判断是家数还是家次
                if (businessFamily.equals("家数")) {
                    int totalFamilyNumber = voList.stream()
                            .mapToInt(JjProgectVo::getFamilyNumber)
                            .sum();
                    // 向上取整 Math.ceil() 商务人数
                    double v = Double.valueOf(totalFamilyNumber) / projectTask.getBusinessSignNum();
                    busTotalPerson = (int) Math.ceil(v);
                } else {
                    // 计算 familyNext 的总和
                    int totalFamilyNext = voList.stream()
                            .mapToInt(JjProgectVo::getFamilyNext)
                            .sum();
                    double v = Double.valueOf(totalFamilyNext) / projectTask.getBusinessSignNum();
                    busTotalPerson = (int) Math.ceil(v);
                }
                list.add(busTotalPerson);
            }
            intList.add(list);
        }

        // 下标集合
        List<List<Integer>> flagList = countPersonFlag(end, intList);
        // 累加集合
        List<List<Integer>> sumTest = countSumFlag(end, intList);
        // 自动向下取整
        Integer num = start / 2;
        for (int i = 0; i < sumTest.size(); i++) {
            List<Integer> currSum = sumTest.get(i);
            List<Integer> currResult = flagList.get(i);
            for (int j = 0; j < currSum.size(); j++) {
                Integer temp = currSum.get(j);

                if (temp <= num) {
                    if (j == 0) {
                        if (j + 1 >= currSum.size()) {
                            currSum.set(j, start);
                        } else {
                            currResult.set(j + 1, currResult.get(j) + 1);
                            currResult.remove(j);
                            currSum.remove(j);
                            j--; // 因为删除了元素，需要减少j
                        }
                    } else {
                        currResult.set(j - 1, currResult.get(j - 1) + 1);
                        currResult.remove(j);
                        currSum.remove(j);
                        j--; // 因为删除了元素，需要减少j
                    }
                } else if (temp < start) {
                    currSum.set(j, start);
                } else {
                    boolean oddFlag = isOdd(temp);
//                    if (!oddFlag) {
//                        currSum.set(j, temp + 1);
//                    }
                    if (!oddFlag) {
                        if (temp > end) {
                            currSum.set(j, temp);
                        } else {
                            currSum.set(j, temp + 1);
                        }
                    }
                }
            }
        }
//        System.out.println(flagList);
//        System.out.println(sumTest);
        // 按照 技术 分组进行 标记
        //  直接去存储数据
        Map<String, List<JjProgectVo>> busTempMap = new HashMap<>();
        Map<String, List<JjProgectVo>> classMap = skillVoList.stream()
                .collect(Collectors.groupingBy(JjProgectVo::getSkillClass));
        int flag = 0;
        for (int i = 0; i < flagList.size(); i++) {
            List<Integer> currResult = flagList.get(i);
            List<Integer> currSum = sumTest.get(i);
            int prevIndex = 0;

            for (int j = 0; j < currResult.size(); j++) {
                int index = currResult.get(j);
                Integer totalNum = currSum.get(j);
                List<JjProgectVo> arrayList = new ArrayList<>();
                for (int k = prevIndex + 1; k <= index; k++) {
                    flag++;
                    String keyName = "技术" + convertToChinese(flag) + "组";
                    List<JjProgectVo> list = classMap.getOrDefault(keyName, Collections.emptyList());
                    // 填入 商务 分组 以及数据
                    for (JjProgectVo vo : list) {
                        // 添加商务组 总人数
                        vo.setBossTotalNum(totalNum);
                    }
                    arrayList.addAll(list);
                }
                prevIndex = index;
                String name = "商务" + convertToChinese(busTempMap.size() + 1) + "组";
                busTempMap.put(name, arrayList);
            }
        }

        List<JjProgectVo> busVos = new ArrayList<>();
        for (int i = 0; i < busTempMap.size(); i++) {
            String keyName = "商务" + convertToChinese(i + 1) + "组";
            List<JjProgectVo> voList = busTempMap.get(keyName);
            // 获取该小组 总人数
            Integer bossTotalNum = voList.get(0).getBossTotalNum();
            // 获取 标段类型
            String signType = voList.get(0).getSignType();
            // 分配异地人数
            //  （商务专家总人数+1）÷3（向上取整）
            double v = Double.valueOf((bossTotalNum + 1)) / projectTask.getOtherSkill();
            int bossOtherNum = (int) Math.ceil(v);

            // 本地
            int localNum = bossTotalNum - bossOtherNum;
            if (localNum < projectTask.getOtherLocal()) {
                // 如果不满足 任务 设定，倒退异地
                localNum = projectTask.getOtherLocal();
                bossOtherNum = bossTotalNum - localNum;
            }
            // 7（4个安徽专家）   7（4个异地）
            String personStr = bossTotalNum + "（" + bossOtherNum + "个异地）";

            if (signType.contains("服务")) {
                for (int j = 0; j < voList.size(); j++) {
                    if (j == 0) {
                        voList.get(j).setBossSignMajor("变电电气设计");
                    } else if (j == 1) {
                        voList.get(j).setBossSignMajor("线路电气设计");
                    } else if (j == 2) {
                        voList.get(j).setBossSignMajor("变电土建设计");
                    } else {
                        voList.get(j).setBossSignMajor("商务综合");
                    }
                }
            }


            Map<String, Integer> sumMap = new HashMap<>();
            for (JjProgectVo gc : voList) {
                // 获取 该 组 专业
                String bossSignMajor = gc.getBossSignMajor();
                int temp = 0;
                if (businessFamily.equals("家数")) {
//                    temp = gc.getFamilyNumber();
                    temp = gc.getFamilyNumber() != null ? gc.getFamilyNumber() : 0;
                } else {
//                    temp = gc.getFamilyNext();
                    temp = gc.getFamilyNext() != null ? gc.getFamilyNext() : 0;
                }
                // 如果 SignMajor 已经在 Map 中，则累加 家数/家次
                if (bossSignMajor != null) {
                    if (sumMap.containsKey(bossSignMajor)) {
                        sumMap.put(bossSignMajor, sumMap.get(bossSignMajor) + temp);
                        // 相同专业 只 保留一个
//                        gc.setBossSignMajor(null);
                    } else {
                        // 否则，将 SignMajor 和 FamilyNumber 放入 Map
                        sumMap.put(bossSignMajor, temp);
                    }
                }
            }

            int count = bossTotalNum;
            // 将 Map 转换为 List，并根据 Integer 值进行排序
            List<Map.Entry<String, Integer>> sortedList = new ArrayList<>(sumMap.entrySet());
            sortedList.sort((entry1, entry2) -> entry2.getValue().compareTo(entry1.getValue()));

            // 求 集合总数
            int totalFamily = 0;
            if (businessFamily.equals("家数")) {
                totalFamily = voList.stream()
                        .mapToInt(JjProgectVo::getFamilyNumber)
                        .sum();
            } else {
                // 计算 familyNext 的总和
                totalFamily = voList.stream()
                        .mapToInt(JjProgectVo::getFamilyNext)
                        .sum();
            }

            Map<String, Integer> personMap = new HashMap<>();
            for (Map.Entry<String, Integer> entry : sortedList) {
                int personNum = 0;
                if (entry.getValue() != 0) {
                    // 计算占比
                    double proportion = (double) entry.getValue() / totalFamily;
                    // 向上取整 Math.ceil()
                    personNum = (int) Math.ceil(proportion * bossTotalNum);
                }
                if (count - personNum < 0) {
                    // 分配剩余的全部
                    personNum = count;
                }
                count -= personNum;
                if (count >= 0) {
                    if (personNum > 0) {
                        personMap.put(entry.getKey(), personNum);
                    }
                }
            }

            Set<String> assignedMajors = new HashSet<>();
            for (Map.Entry<String, Integer> entry : personMap.entrySet()) {
                // 进行专业 对比
                for (JjProgectVo gc : voList) {
                    if (gc.getBossSignMajor() == null) {
                        continue;
                    }

                    if (assignedMajors.contains(gc.getSignMajor())) {
                        continue;
                    }

                    if (gc.getBossSignMajor().equals(entry.getKey())) {
                        gc.setBossMajorNum(entry.getValue());
                        assignedMajors.add(gc.getSignMajor());
                    }
                }
            }
            
            if (signType.contains("服务")) {
                if (voList.size() >= 4) {
                    setMajors(voList, bossTotalNum);
                } else {
                    while (voList.size() < 4) {
                        JjProgectVo vo = new JjProgectVo();
                        vo.setSkillClass(voList.get(0).getSkillClass());
                        voList.add(vo);
                    }
                    setMajors(voList, bossTotalNum);
                }
            }

            for (JjProgectVo gc : voList) {
                // bossTotalStr  商务组专家人数(拼接字符串)
                gc.setBossTotalStr(personStr);
//                // 分组  变电土建商务组7人
                String bossClassName = keyName + bossTotalNum + "人";
                gc.setBossClassStr(bossClassName);
                gc.setBossClass(keyName);
                busVos.add(gc);
            }
        }
        jjProgectMapper.insertBatchJj(busVos, taskId);
    }

    @Override
    public int deleteByTaskId(Integer taskId) {
        return jjProgectMapper.deleteByTaskId(taskId);
    }

    @Override
    public int updateJJProgect(JjProgect jjProgect) {
        return jjProgectMapper.updateJjProgect(jjProgect);
    }

    @Override
    public Page<JjProgect> pageJjProgect(JjParam param) {
        Integer offset = (param.getPageNum() - 1) * param.getPageSize();
        param.setOffset(offset);

        // 分页查询
        Page<JjProgect> page = new Page<>(param.getPageNum(), param.getPageSize());
        List<JjProgect> list = jjProgectMapper.selectJjProgectByPage(param);

        // 页码
        page.setCurrent(param.getPageNum());
        page.setSize(param.getPageSize());

        // 总记录数
        Long aLong = jjProgectMapper.pageJjProgectCount(param);
        page.setTotal(aLong);
        page.setRecords(list);

        return page;
    }

    @Override
    public List<JjProgectVo> selectJjProgectVo(Integer taskId) {
        return jjProgectMapper.selectJjProgectVo(taskId);
    }

    /**
     * 根据 字符串 列表 拼接字符串
     *
     * @param stringList 字符串 列表
     * @return
     */
    public static String joinStrings(List<String> stringList) {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < stringList.size(); i++) {
            sb.append(stringList.get(i));
            if (i < stringList.size() - 1) {
                sb.append(",");
            }
        }
        return sb.toString();
    }


    public static Map<String, List<Integer>> processDeptMap(Map<String, Integer> deptMap) {
        // 初始化空的 mapList
        Map<String, List<Integer>> mapList = new HashMap<>();

        int totalFlag = 0;

        // 遍历 deptMap，动态处理每个部门
        for (Map.Entry<String, Integer> entry : deptMap.entrySet()) {
            String deptName = entry.getKey();
            Integer deptValue = entry.getValue();

            // 创建对应的List
            List<Integer> deptList = new ArrayList<>();

            // 计算整除结果
            int quotient = deptValue / 13;
            if (quotient > 0) {
                for (int i = 0; i < quotient; i++) {
                    deptList.add(13);
                }
            }

            int remainder = deptValue % 13;
            int flag = 0;

            boolean isValidDept = isValidRemainder(remainder);
            if (isValidDept) {
                deptList.add(remainder);
            } else {
                if (remainder > 5) {
                    int[] ints = findTwoOddNumbers(remainder);
                    for (int i : ints) {
                        deptList.add(i);
                    }
                    flag = (ints.length == 1) ? 1 : 0;
                } else {
                    flag = remainder;
                }
            }

            System.out.println(deptName + " 剩余人数: " + flag);
            mapList.put(deptName, deptList);

            totalFlag += flag;
        }

        if (totalFlag > 0) {
            for (Map.Entry<String, List<Integer>> entry : mapList.entrySet()) {
                String key = entry.getKey();
                List<Integer> list = entry.getValue();
                if (!list.isEmpty()) {
                    int index = 0;
                    for (Integer i : list) {
                        if (i < 13 && i + totalFlag < 13) {
                            boolean validJiShu = isValidJiShu(i + totalFlag);
                            if (validJiShu) {
                                list.set(index, i + totalFlag);
                            } else {
                                list.set(index, i + totalFlag + 1);
                            }
                            totalFlag = 0;
                            break;
                        } else if (i + totalFlag >= 13) {
                            list.set(index, 13);
                            totalFlag += i + totalFlag - 13;
                        }
                        index += 1;
                    }
                }
            }
        }

        System.out.println("总剩余: " + totalFlag);
        return mapList;
    }

    private static boolean isValidRemainder(int remainder) {
        return remainder >= 5 && remainder <= 13 && remainder % 2 != 0;
    }

    private static boolean isValidJiShu(int value) {
        return value % 2 != 0;
    }

    private static int[] findTwoOddNumbers(int input) {
        int[] oddNumbers = {5, 7, 9, 11, 13};
        for (int i = 0; i < oddNumbers.length; i++) {
            for (int j = i; j < oddNumbers.length; j++) {
                if (oddNumbers[i] + oddNumbers[j] == input) {
                    return new int[]{oddNumbers[i], oddNumbers[j]};
                }
            }
        }
        return new int[]{input - 1};
    }

    // 传入 数字 返回 其中文样式
    public static String convertToChinese(int number) {
        if (number < 1 || number > 99) {
            throw new IllegalArgumentException("支持的范围是 1 到 99");
        }

        String[] chineseDigits = {"零", "一", "二", "三", "四", "五", "六", "七", "八", "九"};

        int tens = number / 10;
        int units = number % 10;

        StringBuilder result = new StringBuilder();

        if (tens > 0) {
            result.append(chineseDigits[tens]);
            result.append("十");
        }

        if (units > 0 || tens == 0) { // 处理个位是0的情况
            result.append(chineseDigits[units]);
        }

        // 如果只有十位数而个位数是0，不要显示个位的零
        return result.toString().replaceAll("^一十", "十"); // 将 "一十" 转换为 "十"
    }

    public static List<List<Integer>> countPersonFlag(Integer end, List<List<Integer>> intList) {
        List<List<Integer>> result = new ArrayList<>();

        for (List<Integer> list : intList) {
            Integer sum = 0;
            int indexFlag = 1;
            List<Integer> indices = new ArrayList<>();
            for (int i = 0; i < list.size(); i++) {
                sum += list.get(i);
                if (sum >= end || (i < list.size() - 1 && sum + list.get(i + 1) > end)) {
                    // 记录当前索引 + 1
                    indices.add(i + 1);
                    // 将 sum 归零
                    sum = 0;
                }
            }
            if (sum > 0) {
                // 如果循环结束时 sum 还有值，记录最后一个索引
                indices.add(list.size());
            }
            result.add(indices);
        }
        return result;
    }


    public static List<List<Integer>> countSumFlag(Integer end, List<List<Integer>> intList) {
        List<List<Integer>> valuesResult = new ArrayList<>();
        for (List<Integer> list : intList) {
            Integer sum = 0;
            List<Integer> values = new ArrayList<>();
            for (int i = 0; i < list.size(); i++) {
                sum += list.get(i);
                if (sum >= end || (i < list.size() - 1 && sum + list.get(i + 1) > end)) {
                    // 记录当前的累加值
                    values.add(sum);
                    sum = 0;
                }
            }
            if (sum > 0) {
                // 记录最后一个累加值
                values.add(sum);
            }
            valuesResult.add(values);
        }
        return valuesResult;
    }

    public static boolean isOdd(int number) {
        return number % 2 != 0;
    }

    private void setMajors(List<JjProgectVo> voList, Integer totalNum) {
        for (int j = 0; j < voList.size(); j++) {
            if (j == 0) {
                voList.get(j).setBossSignMajor("变电电气设计");
//                voList.get(j).setBossMajorNum(1);
            } else if (j == 1) {
                voList.get(j).setBossSignMajor("线路电气设计");
//                voList.get(j).setBossMajorNum(1);
            } else if (j == 2) {
//                voList.get(j).setBossMajorNum(1);
                voList.get(j).setBossSignMajor("变电土建设计");
            } else {
//                voList.get(j).setBossMajorNum(totalNum - 3);
                voList.get(j).setBossSignMajor("商务综合");
            }
        }
    }
}
